func aliasYodaGreaterThanZero(s string) bool {
	n := len(s)
	return 0 < n // want `use s != "" to check for non-empty string instead of len\(s\) > 0`
}

func aliasYodaGreaterOrEqualOne(s string) bool {
	n := len(s)
	return 1 <= n // want `use s != "" to check for non-empty string instead of len\(s\) >= 1`
}
// + yoda alias variants for < and <=

func sliceGreaterOrEqualOneNotFlagged(s []byte) bool {
	return len(s) >= 1
}

func sliceLessThanOneNotFlagged(s []byte) bool {
	return len(s) < 1
}

func sliceLessOrEqualZeroNotFlagged(s []byte) bool {
	return len(s) <= 0
}

// Tautologies (len(s) >= 0) and contradictions (len(s) < 0) are not flagged.
// Comparisons against 1 that are not equivalent to empty/non-empty (e.g.
// len(s) == 1, len(s) != 1, len(s) <= 1) are also intentionally excluded.

case token.GTR:
    if lit == 0 {
        return token.NEQ, "non-empty", true
    }
    // lit == 1 → len(s) > 1 means at least 2 chars; not equivalent to non-empty.

case token.LEQ:
    if lit == 0 {
        return token.EQL, "empty", true
    }
    // lit == 1 → len(s) <= 1 means 0 or 1 chars; not equivalent to empty.

func TestResolveFixOp(t *testing.T) {
    tests := []struct {
        op    token.Token
        lit   int
        wantOk bool
        wantFix token.Token
    }{
        {token.EQL, 0, true,  token.EQL},
        {token.NEQ, 0, true,  token.NEQ},
        {token.GTR, 0, true,  token.NEQ},
        {token.GEQ, 1, true,  token.NEQ},
        {token.LSS, 1, true,  token.EQL},
        {token.LEQ, 0, true,  token.EQL},
        // non-flagged cases
        {token.GEQ, 0, false, 0}, // tautology
        {token.LSS, 0, false, 0}, // contradiction
        {token.EQL, 1, false, 0}, // len == 1
        {token.NEQ, 1, false, 0}, // len != 1
    }
    for _, tc := range tests {
        fix, _, ok := resolveFixOp(tc.op, tc.lit)
        // assert ok == tc.wantOk, fix == tc.wantFix
    }
}